package juc.blockqueue.linkedtransferqueue;

/**
 * @ClassName TaskDispatcher
 * @PackageName juc.blockqueue.linkedtransferqueue
 * @projectName myThread
 * @Description 3. 任务分发与负载均衡
 * @Author games
 * @Date 2025/9/4 下午3:52
 * @Version 1.0
 */

import java.util.concurrent.LinkedTransferQueue;
import java.util.concurrent.TransferQueue;

class Task {
    private final String taskId;
    private final int priority;

    public Task(String taskId, int priority) {
        this.taskId = taskId;
        this.priority = priority;
    }

    public String getTaskId() {
        return taskId;
    }

    public int getPriority() {
        return priority;
    }

    @Override
    public String toString() {
        return "Task{id='" + taskId + "', priority=" + priority + "}";
    }
}

public class TaskDispatcher {
    public static void main(String[] args) {
        TransferQueue<Task> taskQueue = new LinkedTransferQueue<>();

        // 任务分发器
        /**
         * 创建一个分发线程，用于将任务添加到任务队列中
         * 该线程会创建5个任务，其中前两个为高优先级任务
         */
        Thread dispatcher = new Thread(() -> {
            try {
                // 尝试直接分发高优先级任务
                // 循环创建5个任务
                for (int i = 1; i <= 5; i++) {
                    String taskId = i <= 2 ? "tryTransfer-" : "Task-";
                    // 创建任务对象，前两个任务优先级为1（高优先级），其余为2（普通优先级）
                    Task task = new Task(taskId + 1, i <= 2 ? 1 : 2); // 前两个高优先级

                    // 对于高优先级任务，尝试直接传递
                    if (task.getPriority() == 1) {
                        // 尝试直接传递任务，如果失败则加入队列
                        if (taskQueue.tryTransfer(task)) {
                            System.out.println("高优先级任务直接分发: " + task);
                        } else {
                            taskQueue.put(task);
                            System.out.println("高优先级任务加入队列: " + task);
                        }
                    } else {
                        // 普通任务直接加入队列
                        taskQueue.put(task);
                        System.out.println("普通任务加入队列: " + task);
                    }

                    // 每次任务添加后等待500毫秒
                    Thread.sleep(500);
                }
            } catch (InterruptedException e) {
                // 处理线程中断异常
                Thread.currentThread().interrupt();
            }
        });

        // 工作线程池
        for (int i = 1; i <= 3; i++) {
            final int workerId = i;
            new Thread(() -> {
                try {
                    while (true) {
                        Task task = taskQueue.take();
                        //System.out.println("Worker-" + workerId + " 开始处理: " + task);
                        Thread.sleep(1000 + (task.getPriority() * 500)); // 模拟处理时间
                        System.out.println("Worker-" + workerId + " 完成处理: " + task);
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }, "Worker-" + i).start();
        }

        dispatcher.start();
    }
}

